# -*- coding: utf-8 -*-
 ##############################################
 ##                                            ##
 ##          View for Reportes Package          ##
 ##                                             ##
 ##                                             ##
 ##              from Basiq Series              ##
 ##           by Críptidos Digitales            ##
 ##                 GPL (c)2008                 ##
  ##                                            ##
    ##############################################

"""
"""

from decimal import Decimal, getcontext, ROUND_DOWN, ROUND_UP, ROUND_CEILING
import datetime

from PyQt4 import QtCore, QtGui

import frame_ui
import administradorReportes_ui as administrador_ui
import capturaReporte_ui as captura_ui
import detallesReporte_ui as detalles_ui

from cdWidgets import cdRfcEdit

import manejador as model
import utilities

ID = "venta_id"
VENTA_ID, FOLIO, FECHA, ENTIDAD, SUBTOTAL, DESCUENTOS, IMPUESTOS, TOTAL, STATUS = range(9)
CODIGO, NOMBRE, CLASIFICACION, CANTIDAD, PRECIO, IMPORTE = range(6)


class Forma(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner


    def __init__(self, *args, **kwds):
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = frame_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame1.close()
        self.ui.frame2.close()
        self.ui.frame3.close()

        self.administrador = Administrador(self, owner=self.owner)
        self.detalles = Detalles(self, owner=self.owner)
        self.captura = Captura(self, owner=self.owner)

        self.ui.innerSplitter.insertWidget(0, self.administrador)
        self.ui.innerSplitter.insertWidget(1, self.detalles)

        self.ui.outerSplitter.insertWidget(1, self.captura)

        # self.ui.innerSplitter.setSizes([1, 0])
        # self.ui.outerSplitter.setSizes([1, 0])

        self.detalles.hide()
        self.captura.hide()

        self.connect(self.administrador, QtCore.SIGNAL("changed()"), self.changed)
        self.connect(self.captura, QtCore.SIGNAL("changed()"), self.changed)
        self.connect(self.captura, QtCore.SIGNAL("clientesChanged()"), self.clientesChanged)

        #~ self.connect(session.eventRouter, QtCore.SIGNAL("clientesChanged()"), self.clientesChanged)
        #~ self.connect(session.eventRouter, QtCore.SIGNAL('comprasChangedBroadcast()'), self.comprasChangedBroadcast)
        #~ self.connect(session.eventRouter, QtCore.SIGNAL("productosChanged()"), self.productosChanged)
        #~ self.connect(session.eventRouter, QtCore.SIGNAL('ventasChangedBroadcast()'), self.ventasChangedBroadcast)

    def changed(self):
        self.emit(QtCore.SIGNAL("ventasChanged()"))

    def clientesChanged(self):
        self.emit(QtCore.SIGNAL("clientesChanged()"))

    #~ def comprasChangedBroadcast(self):
        #~ self.emit(QtCore.SIGNAL('comprasChangedBroadcast()'))

    #~ def productosChanged(self):
        #~ self.emit(QtCore.SIGNAL("productosChanged()"))

    #~ def ventasChangedBroadcast(self):
        #~ self.emit(QtCore.SIGNAL('ventasChangedBroadcast()'))



class Administrador(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner

    def __init__(self, *args, **kwds):
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = administrador_ui.Ui_Form()
        self.ui.setupUi(self)

        ## Filtros
        self.ui.laProducto.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")

        ## TABLA DE CONSULTA
        # self.ui.tablaConsulta.setStyleSheet("background-color:#FFFFFF")
        self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.ui.tablaConsulta.setColumnCount(6)
        self.ui.tablaConsulta.setHorizontalHeaderLabels([u"Fecha", u"Monto", u"Status", u"Documento", u"Folio", u""])
        self.ui.tablaConsulta.horizontalHeader().setResizeMode(5, QtGui.QHeaderView.Stretch)
        self.ui.tablaConsulta.sortItems(-1)

        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.mostrarDetalles)

        ## Cuentas por Cobrar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)

        self.aPorCobrar = QtGui.QAction(icon, u"Cuentaspor cobrar", self)
        self.aPorCobrar.setCheckable(True)
        self.aPorCobrar.setIconText(u"Cuentas\npor cobrar")
        self.connect(self.aPorCobrar, QtCore.SIGNAL("triggered()"), self.cuentasPorCobrar)

        self.ui.toCuentasPorCobrar.setDefaultAction(self.aPorCobrar)
        self.ui.toCuentasPorCobrar.setIconSize(QtCore.QSize(44,40))
        self.ui.toCuentasPorCobrar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Cuentas por Pagar
        icon1 = QtGui.QIcon()
        icon1.addPixmap(QtGui.QPixmap("imagenes/Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aPorPagar = QtGui.QAction(icon, u"Cuentaspor pagar", self)
        self.aPorPagar.setCheckable(True)
        self.aPorPagar.setIconText(u"Cuentas\npor pagar")
        self.connect(self.aPorPagar, QtCore.SIGNAL("triggered()"), self.cuentasPorPagar)

        self.ui.toCuentasPorPagar.setDefaultAction(self.aPorPagar)
        self.ui.toCuentasPorPagar.setIconSize(QtCore.QSize(44,40))
        self.ui.toCuentasPorPagar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
        # self.aPorPagar.setChecked(True)

        ## ................................................
        ## Kardex
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Folder.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aKardex = QtGui.QAction(icon, u"&Kardex", self)
        self.aKardex.setCheckable(True)
        self.aKardex.setIconText(u"&Kardex")
        self.connect(self.aKardex, QtCore.SIGNAL("triggered()"), self.kardex)

        self.ui.toKardex.setDefaultAction(self.aKardex)
        self.ui.toKardex.setIconSize(QtCore.QSize(44, 40))
        self.ui.toKardex.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Filtros - Código
        completer = QtGui.QCompleter([], self.ui.edCodigoProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.ui.edCodigoProducto.setCompleter(completer)
        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.codigoProductoSeleccionado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('returnPressed()'), self.codigoProductoCapturado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('textEdited(QString)'), self.codigoProductoEditado)

        ## Filtros - Nombre
        completer = QtGui.QCompleter([], self.ui.edNombreProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self.ui.edNombreProducto.setCompleter(completer)
        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreProductoSeleccionado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL("textEdited(QString)"), self.nombreProductoEditado)

        ## TablaKardex
        labels = [u"Fecha", u"Entidad", u"Documento", u"Cantidad", u"Precio", u"Importe", u"Actual"]
        self.ui.tablaKardex.setColumnCount(len(labels))
        self.ui.tablaKardex.setHorizontalHeaderLabels(labels)

        self.ui.tablaKardex.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)

        ## ................................................
        ## Estados de cuenta
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cash.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aEstadosCuenta = QtGui.QAction(icon, u"&Estados\nde Cuenta", self)
        self.aEstadosCuenta.setCheckable(True)
        self.aEstadosCuenta.setIconText(u"&Estados\nde Cuenta")
        self.connect(self.aEstadosCuenta, QtCore.SIGNAL("triggered()"), self.estadosCuenta)

        self.ui.toEstadosCuenta.setDefaultAction(self.aEstadosCuenta)
        self.ui.toEstadosCuenta.setIconSize(QtCore.QSize(44, 40))
        self.ui.toEstadosCuenta.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boToggle.setIcon(icon)

        ## Filtros - Tipo rol
        self.connect(self.ui.boCliente, QtCore.SIGNAL('clicked()'), self.toggle)
        self.connect(self.ui.boProveedor, QtCore.SIGNAL('clicked()'), self.toggle)
        self.connect(self.ui.boToggle, QtCore.SIGNAL('clicked()'), self.toggle)

        self.tipoRol = u'proveedor'
        self.toggle()

        self.ui.cbNombre.completer().setCompletionMode(QtGui.QCompleter.PopupCompletion)

        ## Filtros - Nombre
        self.connect(self.ui.cbNombre, QtCore.SIGNAL('editTextChanged(QString)'), self.nombreEditado)
        self.connect(self.ui.cbNombre, QtCore.SIGNAL('currentIndexChanged(int)'), self.nombreSeleccionado)

        ## Tabla Estado de Cuenta
        self.ui.taEstadoCuenta.setColumnCount(6)
        self.ui.taEstadoCuenta.setHorizontalHeaderLabels([u"Fecha", u"Documento", u"Estado", u"Deuda", u"Pago", u"Saldo"])


        ## ................................................
        ## Ventas
        self.ui.toVentas.hide()

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap('imagenes/Folder.png'), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aVentas = QtGui.QAction(icon, u"&Ventas", self)
        self.aVentas.setCheckable(True)
        self.aVentas.setIconText(u"&Ventas")
        self.connect(self.aVentas, QtCore.SIGNAL('triggered()'), self.ventas)

        self.ui.toVentas.setDefaultAction(self.aVentas)
        self.ui.toVentas.setIconSize(QtCore.QSize(44, 40))
        self.ui.toVentas.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Filtros - Fechas
        self.ui.laFechasVentas.setStyleSheet("QLabel:enabled{background-color:#A0A0FF; color:#FFFFFF;}")
        self.ui.inicio.setDisplayFormat('dd MMM yyyy')
        self.ui.inicio.setDate(QtCore.QDate().currentDate())
        self.connect(self.ui.inicio, QtCore.SIGNAL("dateChanged(QDate)"), self.fechaVentasChanged)

        self.ui.termino.setDisplayFormat('dd MMM yyyy')
        self.ui.termino.setDate(QtCore.QDate().currentDate())
        self.connect(self.ui.termino, QtCore.SIGNAL("dateChanged(QDate)"), self.fechaVentasChanged)

        ## TablaVentas
        self.ui.tablaVentas.setColumnCount(3)
        self.ui.tablaVentas.setHorizontalHeaderLabels([u"Fecha", "Monto s/IVA", "Monto c/IVA"])

        ## ................................................

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aImprimir = QtGui.QAction(icon, u"Imprimir", self)
        self.aImprimir.setIconText(u"&Imprimir")
        self.connect(self.aImprimir, QtCore.SIGNAL("triggered()"), self.imprime)

        self.ui.toImprimir.setDefaultAction(self.aImprimir)
        self.ui.toImprimir.setIconSize(QtCore.QSize(44, 40))
        self.ui.toImprimir.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)


        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)


        self.connect(session.eventRouter, QtCore.SIGNAL('comprasChanged()'), self.actualizaConsulta)
        self.connect(session.eventRouter, QtCore.SIGNAL('ventasChanged()'), self.actualizaConsulta)

        self.actualizaBotones()

        self.cuentasPorPagar()

        self.upToDate = False



    def acepcionSeleccionada(self, acepcion):
        self.ui.edCodigoProducto.setText(acepcion.codigo)
        self.ui.edNombreProducto.setText(acepcion.nombre)
        self.ui.edClasificacionProducto.setText(acepcion.producto.clasificacion.valor)

        self.acepcion = acepcion

        self.upToDate = False
        self.actualizaConsulta()


    def actualizaBotones(self):
        self.aPorCobrar.setChecked(False)
        self.aPorPagar.setChecked(False)
        self.aKardex.setChecked(False)
        self.aVentas.setChecked(False)
        self.aImprimir.setChecked(False)

        if model.receivablesCount() == 0:
            self.aPorCobrar.setEnabled(False)
            self.aPorCobrar.setToolTip(u"No hay Cuentas por Cobrar")
        else:
            self.aPorCobrar.setEnabled(True)

        if model.payablesCount() == 0:
            self.aPorPagar.setEnabled(False)
            self.aPorPagar.setToolTip(u"No hay Cuentas por Pagar")
        else:
            self.aPorPagar.setEnabled(True)

        if model.getProductCount() == 0:
            self.aKardex.setEnabled(False)
            self.aKardex.setToolTip(u"No hay productos")
            self.ui.frFiltros.setEnabled(False)
            self.ui.frFiltros.setToolTip(u"No hay productos")
        else:
            self.aKardex.setEnabled(True)
            self.aKardex.setToolTip(u"Presiona para mostrar el Manejador de Kardex")
            self.ui.frFiltros.setEnabled(True)
            self.ui.frFiltros.setToolTip(u"")

        if model.getSalesCount() == 0:
            self.aVentas.setEnabled(False)
            self.aVentas.setToolTip(u"No hay Productos")
        else:
            self.aVentas.setEnabled(True)
            self.aVentas.setToolTip(u"Presiona para mostrar el Reporte de Ventas")

        if self.ui.stack.currentIndex() == 0:
            if self.ui.tablaConsulta.rowCount() == 0:
                self.aImprimir.setEnabled(False)
                self.aImprimir.setToolTip(u"No hay cuentas para Imprimir")
            else:
                self.aImprimir.setEnabled(True)
                self.aImprimir.setToolTip(u"Presiona para Imprimir las cuentas mostradas")

        if self.ui.stack.currentIndex() == 1:
            if self.ui.tablaKardex.rowCount() == 0:
                self.aImprimir.setEnabled(False)
                self.aImprimir.setToolTip(u"No hay kardex para Imprimir")
            else:
                self.aImprimir.setEnabled(True)
                self.aImprimir.setToolTip(u"Presiona para imprimir el kardex mostrado")

        if self.ui.stack.currentIndex() == 2:
            if self.ui.tablaVentas.rowCount() == 0:
                self.aImprimir.setEnabled(False)
                self.aImprimir.setToolTip(u"No hay ventas para Imprimir")
            else:
                self.aImprimir.setEnabled(True)
                self.aImprimir.setToolTip(u"Presiona para imprimir las ventas mostradas")


        # if self.aKardex.isChecked():
            # mensajes = u""
            # if manejador.totalDeProductos() == 0:
                # mensajes += u"No hay productos registrados\n"

            # if mensajes:
                # self.aKardex.setEnabled(False)
                # self.aKardex.setToolTip(mensajes.rstrip("\n"))
            # else:
                # self.aKardex.setEnabled(True)
                # self.aKardex.setToolTip(u"Presiona para mostrar el Manejador de Kardex")


    def actualizaConsulta(self):

        if self.isVisible() and not self.upToDate:

            if self.ui.stack.currentIndex() == 0:
                if self.onDisplay == "CuentasPorPagar":
                    registros = model.payables()
                elif self.onDisplay == "CuentasPorCobrar":
                    registros = model.receivables()

                self.ui.tablaConsulta.setRowCount(0)
                self.ui.tablaConsulta.setSortingEnabled(False)

                total = 0

                for index, operacion in enumerate(registros):
                    self.ui.tablaConsulta.insertRow(index)

                    item = QtGui.QTableWidgetItem(operacion['fecha2'].strftime("%d %b %Y"))
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(index, 0, item)

                    item = QtGui.QTableWidgetItem("%.2f" % operacion['monto'])
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(index, 1, item)

                    item = QtGui.QTableWidgetItem(operacion['status'])
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setData(1000, QtCore.QVariant(operacion['operacion_id']))
                    self.ui.tablaConsulta.setItem(index, 2, item)

                    proceso = model.getProcesses(operacion_id=operacion['operacion_id'])[0]

                    operacionCompra = model.getOperaciones(proceso_id=proceso['proceso_id'], operacion_tipo='entrada')[0]

                    # operacionCompra = [x for x in operaciones if x.tipo in ['entrada']][0]

                    documentoCompra = model.getDocumento(operacion_id=operacionCompra['operacion_id'])
                    documentType = model.getAttribute(id=documentoCompra['tipo_id'])
                    rol = model.getRol(id=documentoCompra['rol_id'])

                    item = QtGui.QTableWidgetItem(documentType['nombre'])
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(index, 3, item)

                    item = QtGui.QTableWidgetItem(documentoCompra['folio'])
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(index, 4, item)

                    item = QtGui.QTableWidgetItem("%s %s" % (rol['nombre'], rol['nombre2']))
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaConsulta.setItem(index, 5, item)

                    total += operacion['monto']

                self.ui.tablaConsulta.setSortingEnabled(True)
                self.ui.tablaConsulta.resizeColumnToContents(3)

                self.ui.totalED.setText("%s" % total)

            elif self.ui.stack.currentIndex() == 2:
                ## Kardex
                # movimientos = manejador.damePartidas(producto_id=self.acepcion.producto_id, tipo=[u'Factura', u'Remisión'])
                movimientos = model.damePartidas(producto_id=self.acepcion.producto_id)
                movimientos = [x for x in movimientos if x.documento.tipo.nombre in [u'factura', u'remisión']]

                self.ui.tablaKardex.setRowCount(len(movimientos))

                for index, movimiento in enumerate(movimientos):
                    #~ self.insertRow(index)

                    font = QtGui.QFont()
                    font.setBold(True)

                    item = QtGui.QTableWidgetItem(movimiento.documento.fecha.strftime("%d %b %Y"))
                    item.setFont(font)
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    #~ item.setData(QtCore.Qt.UserRole, QtCore.QVariant(datos['id']))
                    self.ui.tablaKardex.setItem(index, 0, item)

                    item = QtGui.QTableWidgetItem("%s %s" % (movimiento.documento.rol.entidad.nombre, movimiento.documento.rol.entidad.nombre2))
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaKardex.setItem(index, 1, item)

                    item = QtGui.QTableWidgetItem(movimiento.documento.folio)
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaKardex.setItem(index, 2, item)

                    if movimiento.documento.operaciones[0].tipo in [u'entrada']:
                        item = QtGui.QTableWidgetItem("%s" % movimiento.cantidad)
                    elif movimiento.documento.operaciones[0].tipo in [u'salida']:
                        item = QtGui.QTableWidgetItem("%s" % -movimiento.cantidad)

                    # if proceso.tipo in [u'Compra']:
                        # item = QtGui.QTableWidgetItem("%s" % movimiento.cantidad)
                    # elif proceso.tipo in [u'Venta', u'venta']:
                        # item = QtGui.QTableWidgetItem("%s" % -movimiento.cantidad)

                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setTextAlignment(QtCore.Qt.AlignCenter)
                    self.ui.tablaKardex.setItem(index, 3, item)

                    factorDescuento = Decimal("1.00")

                    if movimiento.descuento:
                        factorDescuento = factorDescuento * (100-movimiento.descuento)/100
                    if movimiento.documento.descuentoporcentaje:
                        factorDescuento = factorDescuento * (100-movimiento.documento.descuentoporcentaje)/100

                    costoNeto = movimiento.precio * factorDescuento

                    # item = QtGui.QTableWidgetItem("%.2f" % costoNeto)
                    # item = QtGui.QTableWidgetItem("%.2f" % (movimiento.precioneto))
                    item = QtGui.QTableWidgetItem("%s" % (movimiento.precio*Decimal('1.16')).quantize(Decimal('0.01')))
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
                    self.ui.tablaKardex.setItem(index, 4, item)

                    # item = QtGui.QTableWidgetItem("%.2f" % (movimiento.cantidad * costoNeto))
                    # item = QtGui.QTableWidgetItem("%.2f" % (movimiento.cantidad * movimiento.precioneto))
                    item = QtGui.QTableWidgetItem("%s" % (movimiento.cantidad * movimiento.precio * Decimal('1.16')).quantize(Decimal('0.01')))
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
                    self.ui.tablaKardex.setItem(index, 5, item)

                self.ui.tablaKardex.resizeColumnToContents(0)
                self.ui.tablaKardex.resizeColumnToContents(2)
                self.ui.tablaKardex.resizeColumnToContents(3)
                self.ui.tablaKardex.resizeColumnToContents(4)
                self.ui.tablaKardex.resizeColumnToContents(5)
                self.ui.tablaKardex.resizeColumnToContents(6)

                #!
                actual = self.calcularActual()
                model.modificaActual(producto_id=movimiento.producto_id, actual=actual)

            elif self.ui.stack.currentIndex() == 2:
                ## Ventas
                filtros = {}
                filtros['inicio'] = self.ui.inicio.date()
                filtros['termino'] = self.ui.termino.date()

                datos = model.getSales(**filtros)

                self.ui.tablaVentas.setRowCount(len(datos))

                for index, dato in enumerate(datos):
                    item = QtGui.QTableWidgetItem(dato['fecha'].toString("dd MMM yyyy"))
                    # item.setFont(font)
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    #~ item.setData(QtCore.Qt.UserRole, QtCore.QVariant(datos['id']))
                    self.ui.tablaVentas.setItem(index, 0, item)

                    item1 = QtGui.QTableWidgetItem(str(dato['total']))
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaVentas.setItem(index, 1, item1)

                    item2 = QtGui.QTableWidgetItem(str(dato['total']))
                    item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.ui.tablaVentas.setItem(index, 2, item2)

                    if dato['fecha'].dayOfWeek() == 7:
                        item.setBackgroundColor(QtGui.QColor(255,102,102))
                        item1.setBackgroundColor(QtGui.QColor(255,102,102))
                        item2.setBackgroundColor(QtGui.QColor(255,102,102))

            self.upToDate = True


    def calcularActual(self):
        actual = 0
        for rowIndex in range(self.ui.tablaKardex.rowCount(), 0, -1):
            cantidad = self.ui.tablaKardex.item(rowIndex-1, 3).text().toFloat()[0]
            actual += cantidad
            item = QtGui.QTableWidgetItem("%.2f" % actual)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            self.ui.tablaKardex.setItem(rowIndex-1, 6, item)
        return actual


    def codigoProductoCapturado(self):
        self.setCursor(QtCore.Qt.WaitCursor)

        if self.ui.edCodigoProducto.completer().completionCount() == 1:
            self.ui.edCodigoProducto.setText(self.ui.edCodigoProducto.completer().currentCompletion())

        acepcion = model.acepcionExiste(codigo=unicode(self.ui.edCodigoProducto.text()), rol_id=self.owner.app.holder.id)

        if acepcion:
            self.acepcionSeleccionada(acepcion)

        self.setCursor(QtCore.Qt.ArrowCursor)


    def codigoProductoEditado(self, texto):
        filtros = {}
        filtros['codigo'] = unicode(texto)
        filtros['rol_id'] = -1

        acepciones = model.getAceptions(**filtros)

        ids = [x.id for x in acepciones]
        codigos = ["%s" % x.codigo for x in acepciones]

        self.sender().completer().data = ids
        self.sender().completer().model().setStringList(codigos)


    def codigoProductoSeleccionado(self, completerModelIndex):
        acepcion = model.getAception(id=self.sender().data[completerModelIndex.row()])
        self.acepcionSeleccionada(acepcion)


    def cuentasPorPagar(self):
        self.ui.stack.setCurrentIndex(0)
        self.onDisplay = "CuentasPorPagar"
        self.ui.titulo.setText("Reporte de Cuentas por Pagar")
        self.upToDate = False
        self.actualizaConsulta()


    def cuentasPorCobrar(self):
        self.ui.stack.setCurrentIndex(0)
        self.onDisplay = "CuentasPorCobrar"
        self.ui.titulo.setText("Reporte de Cuentas por Cobrar")
        self.upToDate = False
        self.actualizaConsulta()


    def agrega(self):
        self.parent().parent().parent().captura.agrega()


    def elimina(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar compra", u"Selecciona la COMPRA que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            dato = model.dameUno({'id':id})
            # dato = self.owner.bd.get("compras", {'compra_id': id})
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar compra", u"¿Realmente quieres ELIMINAR la COMPRA %s %s?" % (dato.folio, dato.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                model.elimina({'id':id})
                self.upToDate = False
                self.actualizaConsulta()
                self.emit(QtCore.SIGNAL("changed()"))
                # self.owner.bd.eliminar("compras", {'compra_id': id})


    def fechaVentasChanged(self, date):
        if self.ui.inicio.date() > self.ui.termino.date():
            self.ui.inicio.setDate(self.ui.termino.date())
        self.upToDate = False
        self.actualizaConsulta()


    def imprime(self):                          # print "reportes.igu.Administrador.imprime()"
        pass


    def modifica(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar compra", u"Seleccione la COMPRA que quiere MODIFICAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            self.parent().parent().parent().captura.modifica(id)


    def kardex(self):
        self.ui.stack.setCurrentIndex(2)


    def mostrarDetalles(self, item):
        id = self.ui.tablaConsulta.item(item.row(), 0).data(1000).toInt()[0]
        self.parent().parent().parent().detalles.mostrar(id)
        self.parent().parent().parent().ui.innerSplitter.setSizes([1, 1])


    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)


    def nombreProductoEditado(self, texto):
        filtros = {}
        filtros['nombre'] = unicode(texto)
        filtros['rol_id'] = -1
        # filtros['rol_id'] = self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]
        # if self.ui.edClasificacionProducto.text():
            # filtros['clasificacion'] = unicode(self.ui.edClasificacionProducto.text())

        acepciones = model.getAceptions(**filtros)

        ids = [x.id for x in acepciones]
        nombres = ["%s %s" % (x['nombre'], x['codigo']) for x in acepciones]

        self.sender().completer().data = ids
        self.sender().completer().model().setStringList(nombres)


    def nombreProductoSeleccionado(self, completerModelIndex):
        acepcion = model.getAception(id=self.sender().data[completerModelIndex.row()])
        self.acepcionSeleccionada(acepcion)

    """ ---------- Estados de Cuenta -------------"""

    def cargaNombres(self):
        roles = model.getRoles(tipo=self.tipoRol)
        self.ui.cbNombre.clear()
        for rol in roles:
            self.ui.cbNombre.addItem("%s %s" % (rol['nombre'], rol['nombre2']), QtCore.QVariant(rol['id']))
        self.ui.cbNombre.setCurrentIndex(-1)


    def estadosCuenta(self):
        self.ui.stack.setCurrentIndex(1)


    def nombreEditado(self, text):
        pass
        # if len(text)<3:
            # self.ui.cbNombre.clear()
        # elif len(text)==3:
            # self.cargaNombres()
        # else:
            # self.ui.cbNombre.showPopup()


    def nombreSeleccionado(self, index):
        self.setCursor(QtCore.Qt.WaitCursor)
        rolId = self.ui.cbNombre.itemData(index).toInt()[0]

        documentos = model.getDocumentos(rol_id=rolId)

        self.ui.taEstadoCuenta.setRowCount(len(documentos))

        saldo = Decimal('0.00')
        for index, documento in enumerate(documentos):

            row = len(documentos)-index-1

            operaciones = model.getOperations(documento_id=documento.documento_id)

            item = QtGui.QTableWidgetItem("%s" % documento.fecha.date())
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.taEstadoCuenta.setItem(row, 0, item)

            item = QtGui.QTableWidgetItem("%s %s" % (documento.tipo, documento.folio))
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
            self.ui.taEstadoCuenta.setItem(row, 1, item)

            item = QtGui.QTableWidgetItem(documento.status)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
            self.ui.taEstadoCuenta.setItem(row, 2, item)

            deuda = [x for x in operaciones if x.cuenta==u'Cobros']
            if deuda:
                item = QtGui.QTableWidgetItem("%8.2f" % deuda[0].monto)
                saldo -= deuda[0].monto
            else:
                deuda = [x for x in operaciones if x.cuenta==u'Pagos']
                if deuda:
                    item = QtGui.QTableWidgetItem("%8.2f" % deuda[0].monto)
                    saldo -= deuda[0].monto
                else:
                    item = QtGui.QTableWidgetItem("")
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            self.ui.taEstadoCuenta.setItem(row, 3, item)

            pago = [x for x in operaciones if x.cuenta==u'Caja']
            if pago:
                item = QtGui.QTableWidgetItem("%8.2f" % pago[0].monto)
                saldo += abs(pago[0].monto)
            else:
                item = QtGui.QTableWidgetItem("")
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            self.ui.taEstadoCuenta.setItem(row, 4, item)

            item = QtGui.QTableWidgetItem("%8.2f" % saldo)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            self.ui.taEstadoCuenta.setItem(row, 5, item)

            # self.ui.taEstadoCuenta.resizeColumnToContents(0)
            # self.ui.taEstadoCuenta.resizeColumnToContents(1)
        self.setCursor(QtCore.Qt.ArrowCursor)


    def toggle(self):
        if self.tipoRol==u'cliente':
            self.tipoRol = u'proveedor'
            self.ui.frCliente.hide()
            self.ui.frProveedor.show()
        else:
            self.tipoRol = u'cliente'
            self.ui.frCliente.show()
            self.ui.frProveedor.hide()
        # if len(self.ui.cbNombre.currentText()) > 2:
        self.cargaNombres()


    def ventas(self):
        self.ui.stack.setCurrentIndex(2)





class Captura(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner

    @property
    def modo(self):
        return self.__modo


    def __init__(self, *args, **kwds):      # print "reportes.igu.Captura.__init__()"
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        self.__modo = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = captura_ui.Ui_Form()
        self.ui.setupUi(self)

        # self.setStyleSheet('background-color:#EFEFF8')

        self.ui.cbTipoDocumento.clear()
        tipos = model.getTiposDocumento()
        for tipo in tipos:
            self.ui.cbTipoDocumento.addItem(tipo['nombre'], QtCore.QVariant(tipo['id']))

        self.ui.cbTipoDocumento.setCurrentIndex(self.ui.cbTipoDocumento.findData(model.getDefaultSalesDocumentType()['id']))

        font = QtGui.QFont()
        font.setBold(True)

        self.ui.edFolio.setFont(font)
        self.ui.edFolio.setAlignment(QtCore.Qt.AlignHCenter)

        self.ui.fecha.setDisplayFormat('dd MMM yyyy')

        clienteCompleter = QtGui.QCompleter([], self.ui.edNombreCliente)
        self.modeloCliente = ModeloClientes()
        clienteCompleter.setModel(self.modeloCliente)
        clienteCompleter.setCaseSensitivity(QtCore.Qt.CaseInsensitive)

        QtCore.QObject.connect(clienteCompleter, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreClienteSeleccionado)

        self.ui.edNombreCliente.setCompleter(clienteCompleter)
        self.ui.edNombreCliente.setStyleSheet('background-color:#F8F8FF;')

        self.ui.edNombreCliente.setAllowedLengths(4, 55)
        self.ui.edCalle.setAllowedLengths(0, 40)
        self.ui.edAreaNominal.setAllowedLengths(3, 30)
        self.ui.edAreaNominal.setEmptyAllowed(True)
        self.ui.edLugar.setAllowedLengths(0, 25)

        ## Se carga los clientes al inicio, cualquier actualización se reflejará automáticamente mediante un broadcast.
        self.cargarClientes()

        self.clienteDefault = model.getDefaultCustomer()

        self.cliente = self.clienteDefault

        QtCore.QObject.connect(self.ui.edNombreCliente, QtCore.SIGNAL("textEdited(QString)"), self.nombreClienteEditado)

        completer = QtGui.QCompleter([], self.ui.edNombre)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        QtCore.QObject.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreProductoSeleccionado)

        self.ui.edNombre.setCompleter(completer)
        self.ui.edNombre.setStyleSheet('background-color:#F8F8FF;')
        QtCore.QObject.connect(self.ui.edNombre, QtCore.SIGNAL("textEdited(QString)"), self.nombreEditado)

        ## Tabla Partidas
        self.ui.tablaPartidas = TablaPartidas(self.ui.frame)
        self.ui.tablaPartidas.setStyleSheet('background-color:#F8F8FF;')

        self.ui.verticalLayout_2.insertWidget(3, self.ui.tablaPartidas)

        # self.ui.edSubtotal.setFont(font)
        self.ui.edSubtotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        # self.ui.edDescuento.setFont(font)
        self.ui.edDescuento.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        # self.ui.edImpuesto.setFont(font)
        self.ui.edImpuesto.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        font.setPointSize(9)
        self.ui.edTotal.setFont(font)
        self.ui.edTotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edPago.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edPago.setStyleSheet('background-color:#F8F8FF;')
        self.ui.edCambio.setFont(font)
        self.ui.edCambio.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)

        if self.ui.cbTipoDocumento.currentText() == u'Factura':
            self.ui.tablaPartidas.setImpuestoIncluido(False)
        elif self.ui.cbTipoDocumento.currentText() == u'Remisión':
            self.ui.tablaPartidas.setImpuestoIncluido(True)

        QtCore.QObject.connect(self.ui.cbTipoDocumento, QtCore.SIGNAL("currentIndexChanged(QString)"), self.tipoDocumentoCambiado)

        QtCore.QObject.connect(self.ui.boGuardar, QtCore.SIGNAL("clicked()"), self.guardar)
        QtCore.QObject.connect(self.ui.boCancelar, QtCore.SIGNAL( "clicked()"), self.cancelar)

        QtCore.QObject.connect(self.ui.tablaPartidas, QtCore.SIGNAL("totalChanged"), self.totalChanged)
        QtCore.QObject.connect(self.ui.edPago, QtCore.SIGNAL("editingFinished()"), self.pagoEditingFinished)
        QtCore.QObject.connect(self.parent(), QtCore.SIGNAL("clientesChanged()"), self.cargarClientes)

        # self.agrega()


    def acompletadorNombreActivado(self, completerModelIndex):
        cliente = self.owner.bd.get("clientes", {'cliente_id':self.ui.edNombre.completer().data[completerModelIndex.row()]})
        self.ui.edNombre.data = cliente['cliente_id']
        self.ui.edCalle.setText(cliente['calle'])
        self.ui.edLugar.setText(cliente['lugar'])
        self.ui.edRFC.setText(cliente['rfc'])


    def acompletadorRFCActivado(self, completerModelIndex):
        cliente = self.owner.bd.get("clientes", {'cliente_id':self.ui.edRFC.completer().data[completerModelIndex.row()]})
        self.ui.edNombre.setText("%s %s" % (cliente['nombres'], cliente['apellidos']))
        self.ui.edCalle.setText(cliente['calle'])
        self.ui.edLugar.setText(cliente['lugar'])


    def agrega(self):
        self.__modo = "agrega"
        self.clear()
        # self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "ALTA DE VENTA", None, QtGui.QApplication.UnicodeUTF8))

        self.ui.edFolio.setText(str(model.dameFolio(self.ui.cbTipoDocumento.currentText())))
        self.ui.fecha.setDate(QtCore.QDate().currentDate())

        self.ui.edNombreCliente.setFocus()
        self.datos = []

        self.show()


    def cancelar(self):
        self.clear()
        self.hide()
        self.parent().setSizes([1,1])


    def cargarClientes(self):           # print "reportes.igu.Captura.cargarClientes()"
        # old = self.ui.edNombreCliente.text()
        clientes = model.getCustomers()
        for row, cliente in enumerate(clientes):
            self.ui.edNombreCliente.completer().model().insertRow(row)
            index = self.ui.edNombreCliente.completer().model().index(row, 0)

            self.ui.edNombreCliente.completer().model().setData(index, QtCore.QVariant("%s %s" % (cliente['nombre'], cliente['nombre2'])), QtCore.Qt.DisplayRole)
            self.ui.edNombreCliente.completer().model().setData(index, cliente['id'], QtCore.Qt.UserRole)
        # if old:
            # self.ui.edNombreCliente.setText(old)


    def clear(self):
        self.ui.edCodigo.clear()
        self.ui.edNombre.clear()
        self.ui.edClasificacion.clear()
        clienteDefault = model.dameClienteDefault()
        self.ui.edNombreCliente.setText("%s %s" % (clienteDefault.entidad.nombre, clienteDefault.entidad.nombre2))
        self.ui.edCalle.clear()
        self.ui.edAreaNominal.setText("%s" % clienteDefault.direcciones[0].areanominal)

        if clienteDefault.direcciones[0].lugar:
            self.ui.edLugar.setText(clienteDefault.direcciones[0].lugar.valor)

        self.ui.edRFC.setText(clienteDefault.entidad.rfc)
        self.ui.tablaPartidas.clearContents()
        self.ui.tablaPartidas.setRowCount(0)
        self.ui.edSubtotal.clear()
        self.ui.edDescuento.clear()
        self.ui.edImpuesto.clear()
        self.ui.edTotal.clear()


    def data(self):
        """ Regresa los datos contenidos en los widgets de captura y un
            estatus de validez de bajo nivel generado por los mismos. """
        proceso = {}
        proceso['tipo'] = u'venta'
        proceso['fecha'] = self.ui.fecha.dateTime().toPyDateTime()
        proceso['status'] = u'cerrada'

        datos = {}
        datos['proceso'] = proceso
        datos['tipo'] = unicode(self.ui.cbTipoDocumento.currentText())
        datos['folio'] = self.ui.edFolio.text().toInt()[0]
        datos['fecha'] = self.ui.fecha.dateTime().toPyDateTime()
        datos['entidad_id'] = self.cliente.id
        datos['subtotal'] = Decimal(str(self.ui.edSubtotal.text()))
        datos['descuento'] = Decimal(str(self.ui.edDescuento.text()))
        datos['impuesto'] = Decimal(str(self.ui.edImpuesto.text()))
        datos['total'] = Decimal(str(self.ui.edTotal.text()))
        datos['status'] = u"pendiente"

        datos['partidas'] = self.ui.tablaPartidas.data()

        return datos, self.esValida()


    def datosCliente(self):
        datos = {}
        datos['nombre'] = unicode(self.ui.edNombreCliente.text())
        datos['apellidos'] = unicode(self.ui.edApellidos.text())
        datos['fechanacimiento'] = datetime.date(1,1,1)
        datos['calle'] = unicode(self.ui.edCalle.text())
        datos['colonia']  = unicode(self.ui.edAreaNominal.text())
        datos['codigopostal'] = unicode("")
        datos['lugar'] = unicode(self.ui.edLugar.text())
        datos['personalidad'] = self.ui.edRFC.tipo()
        datos['rfc'] = unicode(self.ui.edRFC.text())
        datos['curp'] = ''
        datos['telefono'] = unicode("")
        datos['agentes'] = unicode("")

        return datos, self.clienteEsValido()


    def esValida(self):
        valida = True
        self.mensajes = ""

        if not self.cliente:
            valida = False
            self.mensajes += u"Falta el cliente o tienen errores"

        # if not self.ui.edNombre.data:
            # valida = False
            # self.mensajes += u"No se ha capturado el %s\n" % ENTIDAD

        # if not self.ui.tablaPartidas.model().rowCount():
            # valida = False
            # self.mensajes += u"No se han capturado partidas\n"

        # if not self.ui.edCodigo.isValid():
            # valida = False
            # self.mensajes += u"%s en el código\n" % self.ui.slideCaptura.ui.edCodigo.message()

        return valida


    def clienteEsValido(self):
        valida = True
        self.mensajes = ""

        if not self.ui.edNombreCliente.isValid():
            valida = False
            self.mensajes += u"%s en el nombre\n" % self.ui.edNombreCliente.message()

        if not self.ui.edCalle.isValid():
            valida = False
            self.mensajes += u"%s en la calle\n" % self.ui.edCalle.message()

        if not self.ui.edAreaNominal.isValid():
            valida = False
            self.mensajes += u"%s en la colonia\n" % self.ui.edAreaNominal.message()

        if not self.ui.edLugar.isValid():
            valida = False
            self.mensajes += u"%s en el lugar\n" % self.ui.edLugar.message()

        if not self.ui.edRFC.isValid():
            valida = False
            self.mensajes += u"%s en el RFC\n" % self.ui.edRFC.message()

        return valida


    def guardar(self):                      # print "reportes.igu.Captura.guardar()"
        if self.ui.cbTipoDocumento.currentText() == u'Factura':
            if self.cliente == self.clienteDefault:
                datos, estatus = self.datosCliente()
                if estatus:
                    self.cliente = model.agregaCliente(datos)
                    self.emit(QtCore.SIGNAL("clientesChanged()"))

        datos, estatus = self.data()
        if estatus:
            if self.modo == "agrega":
                model.agrega(datos)
                self.emit(QtCore.SIGNAL("changed()"))
                self.agrega()
            elif self.modo == "modifica":
                model.modifica(datos)
                self.emit(QtCore.SIGNAL("changed()"))
            QtGui.QMessageBox.information(self, u"Empresa Básica - Ventas", u"Venta registrada correctamente", QtGui.QMessageBox.Ok)
        else:
            QtGui.QMessageBox.warning(self, u"Empresa Básica - Ventas", u"%s" % self.mensajes, QtGui.QMessageBox.Ok)


    def modifica(self, id):
        self.id = id
        self.__modo = "modifica"
        self.clear()
        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "Modificación de Venta", None, QtGui.QApplication.UnicodeUTF8))
        registro = model.dameUno({'id':id})
        self.setData(registro)


    def nombreEditado(self, texto):         # print "reportes.igu.Captura.nombreEditado()"
        filtros = {}
        filtros['nombre'] = unicode(texto)

        productos = model.getProductos(filtros)

        ids = [x.id for x in productos]
        nombres = [x.nombre for x in productos]

        self.sender().completer().data = ids
        self.sender().completer().model().setStringList(nombres)


    def nombreClienteEditado(self, texto):  # print "reportes.igu.Captura.nombreClienteEditado()"
        pass


    def nombreClienteSeleccionado(self, completerModelIndex):
        data = self.sender().completionModel().data(completerModelIndex, QtCore.Qt.UserRole).toInt()[0]

        self.cliente = model.dameCliente({'id':data})
        self.ui.edCalle.setText("%s" % self.cliente.direcciones[0].calle)
        self.ui.edAreaNominal.setText("%s" % self.cliente.direcciones[0].areanominal)
        self.ui.edLugar.setText(self.cliente.direcciones[0].lugar)
        self.ui.edRFC.setText(self.cliente.entidad.rfc)


    def nombreProductoSeleccionado(self, completerModelIndex):
        producto = model.getProducto({'id':self.sender().data[completerModelIndex.row()]})
        datos = {'id':producto.id, 'codigo':producto.codigo, 'nombre':producto.nombre, 'clasificacion':producto.clasificacion, 'importe':0.0, 'cantidad':0.0, 'actual':producto.actual, 'precio':producto.precio}
        row = self.ui.tablaPartidas.rowCount()
        self.ui.tablaPartidas.setDatosRenglon(row, datos)

        self.ui.edNombre.setText("")

        self.ui.tablaPartidas.setCurrentCell(row, CANTIDAD)
        self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(row, CANTIDAD))


    def pagoEditingFinished(self):
        cambio = self.ui.edPago.text().toDouble()[0] - self.ui.edTotal.text().toDouble()[0]
        self.ui.edCambio.setText("%.2f" % cambio)


    def partidasClicked(self, index):
        self.ui.tablaPartidas.edit(index)


    def rfcEditado(self, text):
        filtros = {}
        if text:
            filtros['rfc'] = "LIKE %s%%" % text
        clientes = self.owner.bd.getMany("clientes", filtros)
        ids = [x['cliente_id'] for x in clientes]
        rfcs = [x['rfc'] for x in clientes]
        self.ui.edRFC.completer().data = ids
        self.ui.edRFC.completer().model().setStringList(rfcs)


    def setData(self, data):                # print "reportes.igu.Captura.setData()"
        self.ui.edCodigo.setText(datos['codigo'])
        self.ui.edNombre.setText(datos['nombre'])
        self.ui.edDescripcion.setText(datos['descripcion'])
        self.ui.cbOrigen.setCurrentIndex(self.ui.cbOrigen.findData(QtCore.Qt.UserRole, datos['origen']))
        self.ui.edCosto.setText(datos['costo'])
        self.ui.edMargen.setText(datos['margen'])
        self.ui.edPrecio.setText(datos['precio'])

        self.ui.tablaPartidas.setData(datos.partidas)


    def tipoDocumentoCambiado(self, text):  # print "reportes.igu.Captura.tipoDocumentoCambiado()"
        if text == u'Factura':
            self.ui.tablaPartidas.setImpuestoIncluido(False)
        elif text == u'Remisión':
            self.ui.tablaPartidas.setImpuestoIncluido(True)
        self.ui.edFolio.setText(str(model.dameFolio(text)))


    def totalChanged(self, subtotal):       # print "reportes.igu.Captura.totalChanged()"
        descuento = subtotal * Decimal("0.00")

        # getcontext().rounding = ROUND_DOWN
        if self.ui.tablaPartidas.impuestoIncluido():
            impuesto = Decimal("0.00")
        else:
            impuesto = subtotal * Decimal("0.15")
        # getcontext().rounding = ROUND_UP

        total = subtotal + impuesto
        self.ui.edSubtotal.setText("%.2f" % subtotal)
        self.ui.edDescuento.setText("%.2f" % descuento)
        # getcontext().rounding = ROUND_DOWN
        self.ui.edImpuesto.setText("%.2f" % impuesto)
        # getcontext().rounding = ROUND_HALF_EVEN
        self.ui.edTotal.setText("%.2f" % total)
        if total:
            self.ui.laTotalConLetras.setText("Son %s" % utilities.moneyToText(Decimal(str(total))))


class Detalles(QtGui.QFrame):

    @property
    def owner(self):
        return self.__owner


    def __init__(self, *args, **kwds):

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QFrame.__init__(self, *args)

        self.ui = detalles_ui.Ui_Form()
        self.ui.setupUi(self)


    def mostrar(self, id):
        data = model.dameUno({'id':id})
        self.setData(data)
        self.show()


    def setData(self, data):
        # pedido = model.damePedido({'proceso_id':data.proceso_id})
        self.ui.laFolio.setText("%s" % data.folio)
        self.ui.laFecha.setText(data.fecha.strftime("%d %b %Y"))
        # self.ui.laOrden.setText("%s" % pedido.folio)
        self.ui.laEntidad.setText("%s %s" % (data.entidad.nombre, data.entidad.nombre2))
        self.ui.laSubtotal.setText("%.2f" % data.subtotal)
        self.ui.laDescuento.setText("%.2f" % data.descuento)
        self.ui.laImpuesto.setText("%.2f" % data.impuesto)
        self.ui.laTotal.setText("%.2f" % data.total)

        font = QtGui.QFont()
        font.setWeight(75)
        font.setBold(True)

        for row, partida in enumerate(data.partidas):
            label = QtGui.QLabel(partida.producto.codigo)
            label.setFont(font)
            self.ui.layoutPartidas.addWidget(label, row+1, 0)
            label = QtGui.QLabel(partida.producto.nombre)
            label.setFont(font)
            self.ui.layoutPartidas.addWidget(label , row+1, 1)
            label = QtGui.QLabel(partida.producto.clasificacion)
            label.setFont(font)
            self.ui.layoutPartidas.addWidget(label, row+1, 2)
            label = QtGui.QLabel("%s" % partida.cantidad)
            label.setAlignment(QtCore.Qt.AlignCenter)
            label.setFont(font)
            self.ui.layoutPartidas.addWidget(label, row+1, 3)

            label = QtGui.QLabel("%.2f" % partida.costo)
            label.setAlignment(QtCore.Qt.AlignRight)
            label.setFont(font)
            self.ui.layoutPartidas.addWidget(label, row+1, 4)

            # self.ui.laTotal.setText("%.2f" % partida.cantidad * partida.costo)
            label = QtGui.QLabel("%.2f" % (partida.cantidad * partida.costo))
            label.setAlignment(QtCore.Qt.AlignRight)
            label.setFont(font)
            self.ui.layoutPartidas.addWidget(label, row+1, 5)





class ModeloClientes(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def data(self, index, role=QtCore.Qt.DisplayRole):  # print "reportes.igu.ModeloClientes.data()"
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            return self.__data[index.row()][index.column()]
        elif role == QtCore.Qt.TextAlignmentRole:
            if index.column() == CANTIDAD:
                return QtCore.QVariant(int(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter))
            if index.column() in [PRECIO, IMPORTE]:
                return QtCore.QVariant(int(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter))
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == QtCore.Qt.UserRole:
            return self.__data[index.row()][1]
        else:
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):
        self.__data.insert(row, [QtCore.QVariant(""), QtCore.QVariant("")])
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def reload(self):
        pass


    def setData(self, index, valor, role=QtCore.Qt.DisplayRole):
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            self.__data[index.row()][0] = QtCore.QVariant(valor)
        elif role == QtCore.Qt.UserRole:
            self.__data[index.row()][1] = QtCore.QVariant(valor)
        else:
            print "puaj"
        return True




class TablaPartidas(QtGui.QTableWidget):

    def __init__(self, *args):              # print "reportes.igu.TablaPartidas.__init__()"
        QtGui.QTableView.__init__(self, *args)

        self.__impuestoIncluido = True

        self.setWordWrap(False)
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)

        self.setColumnCount(6)
        self.setHorizontalHeaderLabels([u"Código", u"Nombre", u"Clasificación", u"Cantidad", u"Precio", u"Importe"])
        self.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)

        self.aElimina = QtGui.QAction("Elimina", self)

        self.menu = QtGui.QMenu(self)
        self.menu.addAction(self.aElimina)

        QtCore.QObject.connect(self, QtCore.SIGNAL("itemChanged(QTableWidgetItem *)"), self.recalcula)
        QtCore.QObject.connect(self, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.muestraMenu)
        QtCore.QObject.connect(self.aElimina, QtCore.SIGNAL("triggered()"), self.elimina)


    def dameSubtotal(self):                 # print "reportes.igu.TablaPartidas.dameSubtotal()"
        subtotal = Decimal("0.00")
        for row in range(self.rowCount()):
            importe = Decimal(str(self.item(row, 5).text()))        # Importe
            subtotal += importe
        return subtotal


    def data(self):
        partidas = []
        for row in range(self.rowCount()):
            partida = {}
            partida['producto_id'] = self.item(row, 0).data(QtCore.Qt.UserRole).toInt()[0]
            partida['cantidad'] = Decimal(str(self.item(row, 3).text()))
            partida['costo'] = Decimal(str(self.item(row, 4).text()))
            partida['precio'] = Decimal(str(self.item(row, 4).text()))
            partida['descuento'] = Decimal("0.00")
            partida['impuesto'] = Decimal("15.0")
            partida['status'] = u"ejecutada"
            partidas.append(partida)
        return partidas


    def elimina(self):
        if self.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar partida", u"Selecciona la PARTIDA que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar partida", u"¿Realmente quieres ELIMINAR la PARTIDA?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                self.removeRow(self.currentRow())
                self.emit(QtCore.SIGNAL("totalChanged"), self.dameSubtotal())


    def impuestoIncluido(self):
        return self.__impuestoIncluido


    def muestraMenu(self, pos):
        pos = self.mapToGlobal(pos)
        self.menu.popup(pos)


    def recalcula(self, item=None):         # print "reportes.igu.TablaPartidas.recalcula()"
        if item:
            row = self.row(item)
            if self.column(item) in [3, 4]:
                if self.column(item) == 3:
                    if str(item.data(QtCore.Qt.EditRole).toString()):
                        try:
                            if Decimal(str(item.data(QtCore.Qt.UserRole).toString())) < Decimal(str(item.data(QtCore.Qt.EditRole).toString())):
                                item.setBackgroundColor(QtGui.QColor("#FF8080"))
                            else:
                                item.setBackgroundColor(QtGui.QColor("#FFFFFF"))
                        except:
                            pass
                elif self.column(item) == 4:
                    if self.__impuestoIncluido:
                        item.setData(QtCore.Qt.UserRole+1, item.data(QtCore.Qt.EditRole))
                        item.setData(QtCore.Qt.UserRole+2, QtCore.QVariant(str(Decimal(str(item.data(QtCore.Qt.EditRole).toString())) / Decimal("1.15"))))

                cantidad, status1 = self.item(row, CANTIDAD).text().toFloat()
                if self.item(row, PRECIO):  # Puede ser que no se haya creado aun
                    precio, status2 = self.item(row, PRECIO).text().toFloat()
                    importe = cantidad * precio
                    self.item(row, IMPORTE).setText("%.2f" % importe)
                    self.emit(QtCore.SIGNAL("totalChanged"), self.dameSubtotal())



    def setDatosRenglon(self, index, datos):
        self.insertRow(index)

        font = QtGui.QFont()
        font.setBold(True)

        item = QtGui.QTableWidgetItem(datos['codigo'])
        item.setFont(font)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        item.setData(QtCore.Qt.UserRole, QtCore.QVariant(datos['id']))
        self.setItem(index, CODIGO, item)

        item = QtGui.QTableWidgetItem(datos['nombre'])
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(index, NOMBRE, item)

        item = QtGui.QTableWidgetItem(datos['clasificacion'])
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(index, CLASIFICACION, item)

        item = QtGui.QTableWidgetItem("%s" % datos['importe'])
        self.setItem(index, IMPORTE, item)

        item = QtGui.QTableWidgetItem("%s" % datos['cantidad'])
        self.setItem(index, CANTIDAD, item)
        item.setData(QtCore.Qt.UserRole, QtCore.QVariant(str(datos['actual'])))

        item = QtGui.QTableWidgetItem("%.2f" % datos['precio'])
        item.setData(QtCore.Qt.UserRole+1, QtCore.QVariant(str(datos['precio'])))
        item.setData(QtCore.Qt.UserRole+2, QtCore.QVariant(str(datos['precio'] / Decimal("1.15"))))
        if self.impuestoIncluido():
            item.setData(QtCore.Qt.EditRole, QtCore.QVariant("%.2f" % Decimal(str(item.data(QtCore.Qt.UserRole+1).toString())).quantize(Decimal('0.01'))))
        else:
            item.setData(QtCore.Qt.EditRole, QtCore.QVariant("%.2f" % Decimal(str(item.data(QtCore.Qt.UserRole+2).toString())).quantize(Decimal('0.01'))))
        self.setItem(index, PRECIO, item)
        self.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)
        self.resizeColumnToContents(CODIGO)
        self.resizeColumnToContents(CLASIFICACION)
        self.resizeColumnToContents(CANTIDAD)


    def setImpuestoIncluido(self, value):   # print "reportes.igu.TablaPartidas.setImpustoIncluido()"
        if value:
            self.__impuestoIncluido = True
        else:
            self.__impuestoIncluido = False

        for row in range(self.rowCount()):
            item = self.item(row, 4)       # Precio
            if item:
                if self.__impuestoIncluido:
                    item.setData(QtCore.Qt.EditRole, QtCore.QVariant("%.2f" % Decimal(str(item.data(QtCore.Qt.UserRole+1).toString())).quantize(Decimal('0.01'))))
                else:
                    item.setData(QtCore.Qt.EditRole, QtCore.QVariant("%.2f" % Decimal(str(item.data(QtCore.Qt.UserRole+2).toString())).quantize(Decimal('0.01'))))

            cantidad, status1 = self.item(row, 3).text().toFloat()      # Cantidad
            precio, status2 = self.item(row, 4).text().toFloat()        # Precio
            importe = cantidad * precio
            self.item(row, 5).setText("%.2f" % importe)                 # Importe

        self.emit(QtCore.SIGNAL("totalChanged"), self.dameSubtotal())

